
## Table of Contents

1. [Introduction](#introduction)
2. [Common Issue with Git in Visual Studio](#common-issue-with-git-in-visual-studio)
3. [Conclusion](#conclusion)

## Introduction

This post covers a common issue encountered when using Git within Visual Studio and provides steps to resolve it.

## Common Issue with Git in Visual Studio

### Merge or Commit Error

If you're using Visual Studio's Git merge to merge code from a source branch to a target branch and there are new commits on the target branch, you might see the following error:

```
An error occurred. Detailed message: 2 uncommitted changes would be overwritten by merge
```

You'll probably still see this error after trying to pull from the target branch a couple of times. I think this might be a bug when using Visual Studio's Git integration, but some people say it might be caused by a locked file. Either way, it is something that should work, but Git in Visual Studio is not handling it correctly. The following are fixes I have tried that work so far:

1. After checking out the target branch, always pull first, then perform other operations like merge or push.

2. Although #1 should work most of the time, if you forgot to pull or even after you pull someone else pushes their changes, you might still see the above error.

3. **Restart Visual Studio** — this might work.

4. Open the command line from your current source folder and type the following:

```
git status
git pull
```

## Conclusion

When encountering merge or commit errors in Visual Studio's Git integration, the most reliable fix is to always pull before performing other operations. If the issue persists, try restarting Visual Studio or using the command line directly.


Common issues and fixes when using Git with Visual Studio.

Git with Visual Studio


## Table of Contents

1. [Introduction](#introduction)
2. [Steps](#steps)
3. [Result](#result)
4. [Bonus: For Git Users](#bonus-for-git-users)
5. [Conclusion](#conclusion)

## Introduction

When you build a solution in Visual Studio, NuGet restores packages and downloads DLLs into a `packages` folder. You should **not** check these files into source control — they can be restored automatically, and committing them bloats your repository.

This guide shows how to properly ignore the NuGet `packages` folder when using **TFS (Team Foundation Server)** as your source control.

## Steps

### 1. Create the `.nuget` Folder

At the root of your Visual Studio solution, create a `.nuget` folder and add a `NuGet.config` file inside it.

### 2. Create the `.tfignore` File

At the root of your Visual Studio solution, create a `.tfignore` file.

Your solution structure should look like this:

```
MySolution/
├── .nuget/
│   └── NuGet.config
├── .tfignore
├── MySolution.sln
├── MyProject/
└── packages/          ← This folder will be ignored
```

### 3. Add `NuGet.config` Content

Inside `.nuget/NuGet.config`, add the following to disable source control integration for the packages folder:

```xml
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <solution>
    <add key="disableSourceControlIntegration" value="true" />
  </solution>
</configuration>
```

### 4. Add `.tfignore` Content

In the `.tfignore` file, add the packages folder path:

```
\packages
```

## Result

After adding these two files, when you check in your changes via TFS, files and folders under the `packages` directory will **no longer appear** in your Pending Changes window.

## Bonus: For Git Users

If you're using **Git** instead of TFS, add this line to your `.gitignore` file:

```
packages/
```

Most Visual Studio `.gitignore` templates already include this by default.

## Conclusion

| File           | Location              | Purpose                                   |
| -------------- | --------------------- | ----------------------------------------- |
| `NuGet.config` | `.nuget/NuGet.config` | Disables NuGet source control integration |
| `.tfignore`    | Solution root         | Tells TFS to ignore the `packages` folder |

This simple setup keeps your repository clean and avoids unnecessary package files in source control.


How to exclude the NuGet packages folder from source control in Visual Studio using .tfignore and NuGet.config.

A Tip for Ignoring NuGet Packages Folder in Visual Studio


If you use Xamarin at windows and want to build app for Android and iOS, you
could use iOS simulator at your windows. However there's few software and
setting you might have to do. I assume you're having problem at windows
Xamarin Mac Agent and unable to connect to your mac.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_0l7ux5l96.png)

First make sure your windows have following software installed.

  - Window PC

    - Visual Studio 2015

    - Xamarin for Visual Studio 2015

Mac

    - Enable Remote login

    - Xamarin Studio (Xamarin Mac Agent need your Mac to have Mono installed)

Others

    - Make sure Mac and Window are at the same network.

    - Still can't not connect to Mac, download PuTTY to test connection

    - Or check here to see xamarin error, you might found useful message when
you can't connect to Mac. C:\Users\{Your Windows User
Account}\AppData\Local\Xamarin\Logs\14.0


Xamarin - Can't Connect to Mac From Windows with Xamarin


## Table of Contents

- [Introduction](#introduction)
- [Modify Visual Studio Version in the Solution File](#modify-visual-studio-version-in-the-solution-file)
- [Change Visual Studio Compare and Merge to WinMerge](#change-visual-studio-compare-and-merge-to-winmerge)
- [Install Visual Studio Extensions](#install-visual-studio-extensions)
- [Conclusion](#conclusion)

## Introduction

This post covers the steps needed to upgrade from Visual Studio 2013 to Visual Studio 2015, including updating the solution file, configuring WinMerge for compare and merge, and installing useful extensions.

## Modify Visual Studio Version in the Solution File

Before:

```
# Visual Studio 2013
VisualStudioVersion = 12.0.30723.0
```

After:

```
# Visual Studio 14
VisualStudioVersion = 14.0.23107.0
```

## Change Visual Studio Compare and Merge to WinMerge

If you don't like Visual Studio's default compare and merge tool and prefer WinMerge, here's how to set it up. Click Visual Studio **Tools**, open the **Source Control** tab, click **Visual Studio Team Foundation Server**, then click **Configure User Tools**.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_mxg1x4cpi.png)

### Add Compare to Use WinMerge

![](https://d1p0mp3f1fx0hz.cloudfront.net/_4ta90k4la.png)

### Add Merge to Use WinMerge

![](https://d1p0mp3f1fx0hz.cloudfront.net/_nloprewmk.png)

## Install Visual Studio Extensions

You can install the following Visual Studio extensions for web development:

- Web Essentials 2015.1
- Web Essentials - Web Compiler
- Web Essentials - Bundler & Minifier
- Web Essentials - Image Optimizer
- Web Essentials - Web Analyzer
- CodeMaid

## Conclusion

Upgrading from Visual Studio 2013 to 2015 involves updating the solution file version, optionally configuring WinMerge for a better compare and merge experience, and installing useful web development extensions. These steps ensure a smooth transition to the newer IDE.


A guide on upgrading from Visual Studio 2013 to Visual Studio 2015, including solution file changes, configuring WinMerge, and recommended extensions.

Upgrade Visual Studio 2013 v4 to Visual Studio 2015


## Table of Contents

1. [Introduction](#introduction)
2. [Install Node.js Tools for Visual Studio](#install-nodejs-tools-for-visual-studio)
3. [Debug Your Node.js App](#debug-your-nodejs-app)
4. [Conclusion](#conclusion)

## Introduction

Scott already wrote a blog in 2013 about the Node.js tools for Visual Studio, so for more detailed information you can find it at Introducing Node.js Tools for Visual Studio. This blog shows how to run debugging in practice.

## Install Node.js Tools for Visual Studio

First, you need to install Node.js tools for your Visual Studio. Go to the following page to download it, and this assumes you already have Node.js and Visual Studio installed.

NodejsTools For Visual Studio

## Debug Your Node.js App

Open your Node.js project and click the browser button (in the following example, click Google Chrome).

![](https://d1p0mp3f1fx0hz.cloudfront.net/_7ajncpu6n.png)

Node.js tools will use node.exe to open another port to start debugging your Node.js app.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_eblqr33je.png)

There you go, you are done. You can use Visual Studio's debug tools now.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_02klxb24j.png)

## Conclusion

Debugging Node.js in Visual Studio is simple: install the Node.js Tools extension, open your project, and launch it with a browser. For more information about Node.js debugging in Visual Studio, please reference the following:

  - Advanced Debugging

  - nodejstools download


How to debug a Node.js app in Visual Studio.

How to Debug Node.js Code with Visual Studio


## Table of Contents

- [Introduction](#introduction)
- [The Problem](#the-problem)
- [Conclusion](#conclusion)

## Introduction

![](https://d1p0mp3f1fx0hz.cloudfront.net/_ytp13gif8.png)

I think I need to stop using Visual Studio with Node.js projects. I was using Sublime Text with my Node.js project with no problems — running Node.js commands and opening Sublime for my project took only a second.

## The Problem

However, when I open my Node.js project with Visual Studio, I can hear my computer dying. Once I open Visual Studio 2013, it uses around 20–30% of my CPU and 2 GB of memory. I could also hear my computer making strange sounds from the fan.

I think the main issue with Visual Studio and Node.js is that Visual Studio uses a lot of macros to load the project files, which might cause the problem as the application is constantly checking something.

This issue should be fixed if you're using Visual Studio 2017 or later.

## Conclusion

If you're working with Node.js projects, consider using a lightweight editor like Sublime Text or VS Code instead of Visual Studio 2013. The heavy resource usage from Visual Studio makes it impractical for Node.js development. Later versions of Visual Studio (2017+) have improved this experience.


Why you should stop using Visual Studio 2013 for Node.js projects due to performance issues.

Stop Using Visual Studio 2013 with Node.js Project


## Table of Contents

1. [Introduction](#introduction)
2. [ASP.NET Solution Template](#aspnet-solution-template)
3. [Web Essentials](#web-essentials)
4. [Productivity Power Tools](#productivity-power-tools)
5. [Ionic Tabs Template](#ionic-tabs-template)
6. [Paid Extensions](#paid-extensions)
7. [Conclusion](#conclusion)

## Introduction

Here are a few useful Visual Studio extensions for .NET developers that can improve productivity and streamline development workflows.

## ASP.NET Solution Template

A solution layout for a typical ASP.NET web application, pre-configured
with Git, Gulp.js, NuGet, and StyleCop development tools. It is well suited
for developing a single-page application (SPA).

**ASPNET MVC ANGULAR Project Template** — Installation for ASP.NET MVC Angular project Visual Studio extension.

**CodeMaid** — CodeMaid is an open source Visual Studio extension to clean up, dig through,
and simplify your C#, C++, F#, VB, PHP, JSON, XAML, XML, ASP, HTML, CSS,
LESS, SCSS, JavaScript, and TypeScript coding.

## Web Essentials

[Web Essentials](https://visualstudiogallery.msdn.microsoft.com/359f4304-57d7-4178-9cab-165e2090dce2) — If you ever write CSS, HTML, JavaScript, TypeScript, CoffeeScript, or LESS,
then you will find many useful features that make your life as a developer
easier.

## Productivity Power Tools

**Productivity Power Tools** — A set of extensions to Visual Studio 2013 Professional (and above) which
improves developer productivity.

**Indent Guides** — Adds vertical lines at each indent level.

**Task Runner Explorer** — Provides custom task runner support to Visual Studio.

**GhostDoc** — GhostDoc is a Visual Studio extension that automatically generates XML
documentation comments for methods and properties based on their type,
parameters, name, and other contextual information.

## Ionic Tabs Template

[Ionic Tabs Template](https://visualstudiogallery.msdn.microsoft.com/dbcb8670-889e-4a54-a226-a48a15e4cace) — Build a cross-platform hybrid mobile app for iOS, Android, and Windows
Phone with the Ionic Framework and Apache Cordova. This project comes with
a simple tab-based layout.

## Paid Extensions

Paid extensions for Visual Studio: ReSharper, OzCode, NCrunch, .NET Reflector.

## Conclusion

These extensions can greatly enhance your Visual Studio development experience. Whether you need code cleanup, productivity boosts, or cross-platform tooling, there is an extension to help.


A list of useful Visual Studio extensions for .NET developers, including tools for code cleanup, productivity, and cross-platform development.

Few Useful Visual Studio Extensions for .NET


#### Table of Contents

1. Install packages
2. Create AngularJS app module
3. Create AngularJS controller
4. Write Javascript Unittest
5. Get Chutzpah Test Adapter

The following blog shows how to run the AngularJS unit test just like how you
run C# unit test, so basically, you'll run your AngularJS at the visual studio
test explorer window.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_y17k78x5n.png)

## Install packages

You'll need to install the following two packages,
`AngularJS.Core` and `JasmineTest`.

```
install-package AngularJS.Core
```

```
install-package JasmineTest
```

## Create AngularJS app module

```
var app = angular.module('app', []);
```

## Create AngularJS controller

Just create a simple controller with score.test is test.

```
app.controller('myController', function ($scope) {
    $scope.test = 'test';
});
```

## Write Javascript Unittest

Following this, we'll create a Javascript unit test code by Jasmine.

```
///
describe('testAngular ', function () {
    //initialize Angular
    beforeEach(module('app'));
    var scope;
    beforeEach(inject(function ($controller, $rootScope) {
        scope = $rootScope.$new();
        var ctrl = $controller('myController', { $scope: scope });
    }));

    it('test scope is test', function () {
        expect(scope.test).toBe('test');
    });
});
```

## Get Chutzpah Test Adapter

Chutzpah Test Adapter for the Test Explorer

Once you install Chutzpah you can just run the unit tests like C# unit tests.


Enable javascript unit test at Visual Studio Test Explorer window

Javascript Unit Test With Jasmine, Angular and Chutzpah with Visual Studio


## Table of Contents

1. [Introduction](#introduction)
2. [Install Bootstrap Sass via NuGet](#install-bootstrap-sass-via-nuget)
3. [Install Web Compiler](#install-web-compiler)
4. [Conclusion](#conclusion)

## Introduction

How can you use Bootstrap Sass in Visual Studio? There are many ways to achieve this, but you can simply use NuGet with Visual Studio along with the Web Compiler extension.

## Install Bootstrap Sass via NuGet

Use NuGet to download the Sass Bootstrap package to your web application.

Twitter.Bootstrap.Sass

`PM> Install-Package Twitter.Bootstrap.Sass`

![](https://d1p0mp3f1fx0hz.cloudfront.net/_jzluib1ec.png)

## Install Web Compiler

Once you have installed the Bootstrap files in your application, you can install
the following Visual Studio plugin to compile the Sass to CSS.

Web Compiler

This web compiler will compile the Sass into a CSS file for you.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_662y1ulxw.png)

## Conclusion

Using NuGet to install Bootstrap Sass and the Web Compiler extension to compile it is the simplest approach in Visual Studio 2015. If you want to customize Bootstrap further, the easiest way is to use a tool like http://bootstrap-live-customizer.com/ to get the `variables.less` and `bootstrap.css`. Avoid using only the customized `bootstrap.min.css`, as it will be hard to maintain what has been customized.


How to use Bootstrap Sass at Visual Studio using NuGet and Web Compiler.

How to Use Bootstrap SCSS at Visual Studio 2015


## Table of Contents

- [Introduction](#introduction)
- [Install and Uninstall a Package](#install-and-uninstall-a-package)
- [Update a Package](#update-a-package)
- [Update Project by Defined Nuget File](#update-project-by-defined-nuget-file)
- [Install Nuget Package to All Projects](#install-nuget-package-to-all-projects)
- [Install Nuget Package to Certain Projects](#install-nuget-package-to-certain-projects)
- [Conclusion](#conclusion)

## Introduction

Nuget is a dependency management system for web development. If you use it, you'll already be familiar with the following commands.

## Install and Uninstall a Package

The first Nuget command is to install Angular, and the second one is to uninstall a Nuget package.

```
Install-Package angularjs -Version 1.4.6
```

```
UnInstall-Package angularjs
```

## Update a Package

Nuget actually has more useful commands, like the following. Update a particular package in a project to the latest version:

```
Update-Package jQuery -ProjectName MyProject
```

This command is very useful too because it is able to reinstall all the packages for a specific project.

```
Update-Package -ProjectName MyProject -reinstall
```

## Update Project by Defined Nuget File

```
Update-Package -ProjectName Pokemon.Shared -reinstall
```

```
update-package -reinstall -ignoreDependencies
```

## Install Nuget Package to All Projects

Install a Nuget package to all projects in the current solution:

```
Get-Project -All | Install-Package Autofac
```

## Install Nuget Package to Certain Projects

Install a Nuget package to specific projects in the current solution:

```
Get-Project ProjectA,ProjectB,ProjectC | Install-Package Autofac
```

For more commands, see the following links:

- Nuget Update command
- Nuget command line reference
- Package Manager Console Powershell Reference
- Nuget Create and Publish command

## Conclusion

Nuget provides a rich set of commands for managing packages in your .NET projects. From installing and uninstalling individual packages to batch operations across multiple projects, these commands can significantly streamline your dependency management workflow.


Nuget is a dependency management system for web development. If you use it, you'll already be familiar with the following commands. The first Nuget command is to install Angular, and the second one is to uninstall a Nuget package.

List of Useful Commands for Nuget

## Table of Contents

- [Introduction](#introduction)
- [Copying Files During Build or Deploy](#copying-files-during-build-or-deploy)
- [Example pubxml](#example-pubxml)
- [What's Next](#whats-next)
- [Conclusion](#conclusion)

## Introduction

Here are a few tips for deploying ASP.NET web applications.

For enterprise ASP.NET web application scenarios, please reference the following documents:

- Deploying Web Applications in Enterprise Scenarios
- Understanding the Project File
- Deployment made simple using Powershell

## Copying Files During Build or Deploy

During the application build or deploy, if you have anything that needs to be included but is not checked in to the project, you can try the following approach.

The following is an example command that during the project build will copy files or folders to a specific location depending on whether you are building locally or deploying. If you use PowerShell to write your own deployment scripts, the following `.csproj` code will copy the files or folders, so you don't need to write that in PowerShell.

```




    

    


```

## Example pubxml

The following does almost the same thing as the previous code, however it uses a project publish profile (`.pubxml`).

```
<?xml version="1.0" encoding="utf-8"?>
FileSystem
    YourConfigurationName
    Any CPU

    True
    False
    C:\YourLocalFolder
    False



      <_CustomFiles Include="$(MSBuildProjectDirectory)\TargetFolder\**\*" />

        TargetFolder\%(RecursiveDir)%(Filename)%(Extension)




    copyAdditionalFilesOrFolderForDeploy;;


```

Powershell Gallery

## What's Next

For deployment, you should use Visual Studio 2015's DevOps deployment tools.

## Conclusion

Deploying ASP.NET web applications can be streamlined by configuring your project files and publish profiles to handle file copying automatically. For enterprise scenarios, consider using PowerShell scripts and Visual Studio's built-in DevOps tools for a more robust deployment pipeline.

Tips and examples for deploying ASP.NET web applications, including project file configuration and publish profiles.

Tips About How to Deploy ASP.NET Web Application


## Table of Contents

1. [Introduction](#introduction)
2. [WebEssentials](#webessentials)
3. [Related Tools](#related-tools)
4. [Conclusion](#conclusion)

## Introduction

I wanted to compile Bootstrap Sass, so I searched online and on the
Bootstrap website. The site mentions that Bootstrap supports Sass but doesn't provide details on how to
compile it. That makes sense because there are so
many tools that can compile Sass into CSS. I know that Visual Studio 2015's
compiler plugin makes it very easy to compile Bootstrap Sass into CSS. But
since I'm in Visual Studio 2013 and I like using npm (Node.js package management
system), I wondered if npm had some Sass compiler. So I found
the following — it could work but requires a Grunt file setup and also needs Ruby and
Compass.

That's a lot of work...

```
grunt-contrib-sass
```

So, what I ended up with...

## WebEssentials

WebEssentials is a web tools extension for Visual Studio. First, I ran NuGet to get the Sass
version of Bootstrap.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_5u3gicubz.png)

Then I just created another file called bootstrap.scss and copied the code from
_bootstrap.scss to my bootstrap.scss.

Save, and that causes WebEssentials to compile the SCSS to CSS for me.
Sweet!

![](https://d1p0mp3f1fx0hz.cloudfront.net/_l271mtigm.png)

Now, you can start changing the variables inside the Bootstrap SCSS to use the
real power of Bootstrap.

## Related Tools

  - Web Essentials 2013.5

    - If you ever write CSS, HTML, JavaScript, TypeScript, CoffeeScript, or LESS,
then you will find many useful features that make your life as a developer
easier. This is for all web developers using Visual Studio.

  - NSass

    - NSass is a .NET wrapper around the libsass library. All information about
libsass itself can be found in the readme file under the NSass.LibSass
directory.

## Conclusion

Using WebEssentials in Visual Studio 2013 is the simplest way to compile Bootstrap Sass into CSS. Just install the NuGet Sass version of Bootstrap, create a `.scss` file, and WebEssentials will automatically compile it to CSS on save.


How to compile Bootstrap Sass to CSS in Visual Studio 2013 using WebEssentials.

How to Compile Bootstrap Sass in Visual Studio 2013


## Table of Contents

- [Introduction](#introduction)
- [Could Not Load File or Assembly](#could-not-load-file-or-assembly)
- [The Solution](#the-solution)
- [Conclusion](#conclusion)

## Introduction

This blog is for when you deploy ASP.NET MVC with NuGet to a Windows server and get an error that assemblies can't be loaded. For example, if you use ASP.NET's bundle feature, which is `System.Web.Optimization`, this blog might help your problem by changing the project reference setting. Basically, you have to change the reference's "Copy Local" property to true.

## Could Not Load File or Assembly

The long story is that after coding your ASP.NET MVC (4 or 5) application, everything works fine on your local machine or local IIS. You also use NuGet as a package manager for your web application, so that during the build, Visual Studio will automatically get the version from nuget.org or other NuGet package providers. My point is everything works fine on your local machine. Now you want to deploy to a web server, assume a Windows server.

So, most of the time it works fine, but sometimes after your deployment, errors appear.

My problem was that my web application used `System.Web.Http`, `System.Web.Http.WebHost`, `System.Web.Optimization`, and `Newtonsoft.Json`. I noticed that I couldn't find any of these inside my web server's bin folder. So, something was wrong with my NuGet setup, or I thought I wasn't doing something correctly.

## The Solution

Should I copy all the NuGet package folders to the web server? When I thought about it, I just needed all the DLLs to be inside the bin folder. Can NuGet do that? I haven't found a way for NuGet to do this directly, but after NuGet adds project references, if the DLL setting's "Copy Local" is set to false, then changing it to true will copy the DLL to the bin folder during the build.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_1d9o29c1o.png)

## Conclusion

When deploying ASP.NET MVC applications that use NuGet packages, ensure that all required assemblies have their "Copy Local" property set to true in the project references. This ensures the DLLs are copied to the bin folder during the build and are available on the web server after deployment.


If you are getting an error such as "Could not load file or assembly" in IIS when deploying ASP.NET, this blog might help you resolve the issue.

Troubleshooting Issue When Deploy ASP.NET MVC5 to Windows Server


## Table of Contents

- [Introduction](#introduction)
- [Disable Browser Link](#disable-browser-link)
- [What Is Browser Link For?](#what-is-browser-link-for)
- [Conclusion](#conclusion)

## Introduction

This post shows how to turn off the Browser Link feature in Visual Studio 2013.

## Disable Browser Link

You might already know about this, but if you don't and have noticed the following request **poll?transport= [GET]** that keeps firing requests in your browser, it can be quite annoying.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_cuhszgcan.png)

You can turn off "Enable Browser Link" from Visual Studio 2013 as shown below:

![](https://d1p0mp3f1fx0hz.cloudfront.net/_4oa3hm9x3.png)

## What Is Browser Link For?

Browser Link is turned on by default and is supposed to help test multi-browser UI layouts. For instance, if you add an element and want to check how it looks across all browsers, Browser Link can help. However, it doesn't always work, and you may need to set up your project in a specific Visual Studio-compatible way.

For more information on how to use Browser Link, see the following:

http://blogs.msdn.com/b/webdev/archive/2013/06/28/browser-link-feature-in-visual-studio-preview-2013.aspx

## Conclusion

If the Browser Link feature in Visual Studio 2013 is causing unwanted polling requests in your browser, simply disable it from the toolbar. While it's meant to aid multi-browser testing, it can be more of a nuisance than a help in many cases.


How to turn off the Browser Link feature in Visual Studio 2013 to stop the annoying poll?transport= GET requests in your browser.

How to Turn Off Browser Link for Visual Studio


1. show Line numbers

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1410456001/ytb59vhhzy644mchscqc.png)

2. Custom Compare, Merge Tools

![](https://d1p0mp3f1fx0hz.cloudfront.net/_41ebsw07a.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/_7in72xeli.png)

/x /e /ub /wl /dl %6 /dr %7 %1 %2

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1410456513/knga2cpzueagt0slr1u1.png)

/x /e /ub /wl /dl %6 /dr %7 %1 %2 %4

3. Track Active Item in Solution Explorer

Check this whenever you open a class file, solution exploer will point to
that file, so you know what location is that file.

Check the item under, Tools - Options - Projects and Solutions - General

Check the "Track Active Item in solution Explorer

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1410465518/migfdwme9x3oew5zra7o.png)

4. Turn on IntelliSense Options

![](https://d1p0mp3f1fx0hz.cloudfront.net/_tg4e1dpa9.png)


Few Visual Studio 2013 Helpful Settings


After installed following tools, you should be able to use git with visual
studio 2012.

1. Install Visual Studio 2012 update 4

2. Install Visual Studio Git Tool

3. restart visual studio

Open Team Exploer, then you'll see Git selection.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_08g77sh2o.png)


This is a memo about how to use Git with Visual Studio 2012.